<!DOCTYPE html>
<html lang="en">

<head>
	<meta charset="UTF-8">
	<meta name="viewport" content="width=device-width, initial-scale=1.0">
	<title>Document</title>
</head>

<body>
	<!-- 1.let和var的区别
	var有变量提升,let没有;
	var声明的变量是全局的,let是局部的;
	var声明过的变量还可以再次声明,let不可以,会产生暂时性死区; -->

	<!-- 2.简要描述一下变量提升机制
	用var和function声明的函数会有变量提升，所谓变量提升，就是声明的变量会提到作用域的最上面；
	如var a= 1会提升var a，这时a为undefined；function fn()变量提升fn并执行 -->

	<!-- 3.函数的上级作用域由什么决定
	是由函数定义的位置决定的 -->

	<!-- 4.什么是闭包？
	闭包的形成：
	(1)在一个函数内部定义了另一个函数。
	(2)内部函数使用了外部函数的变量。
	(3)外部函数返回了内部函数，并且内部函数引用了外部函数的变量。
	闭包可以用在许多地方。它的最大用处有两个，一个是前面提到的可以读取函数内部的变量，另一个就是让这些变量的值始终保持在内存中。 -->


</body>
<script src="">
	function fn(...args) {
		let arr = args
		function sum() {

		}
		let value = {

		}

		return sum
	}

	// fn(1)(2).value()
</script>
<script src="">
	Array.prototype._forEach = function _forEach(callback) {
		for (let i = 0; i < this.length; i++) {
			callback(this[i], i, this)
		}
	}

	let ary = [12, 23, 12, 13, 13, 12, 23, 14, 8];
	ary._forEach((item, index, array) => {
		console.log(item, index, array);
	})
</script>
<script src="">
	Array.prototype._map = function _map(callback) {
		let arr = []
		for (let i = 0; i < this.length; i++) {
			arr.push(callback(this[i], i, this))
		}
		return arr
	}

	let arry = [1, 2, 3, 4];

</script>
<script src="">
	function Fn(num) {
		this.x = this.y = num
	};
	Fn.prototype = {
		x: 20,
		sum: function () {
			console.log(this.x + this.y);
		}
	};
	let f = new Fn(10);
	console.log(f.constructor);  // object(){["native code"]} 
</script>
<script src="">
	let x = 2;
	var obj = {
		x: 3,
		z: (function (x) {
			return function () {
				x = 5;
				console.log(this.x);  // 
			}
		})(x)
	}
	var ff = obj.z
	ff() 
</script>
<script src="">
	let obj = {
		name: 'lili'
	}
	const fn = function fn(x, y) {
		console.log(this, x, y)
		return x + y
	}

	Function.prototype._call = function _call(target, ...args) {
		// 如果传递进来的
		if (target == null) target = window

		if (!/^(function|object)$/.test(typeof target)) target = Object(target)

		let result, key = Symbol('key')
		target[key] = this
		result = target[key](...args)
		delete obj[key]

		return result

	}




</script>
<script src="">
	let obj = {
		x: 100,
		y: [10, 30, 40]
	};
	let obj2 = obj;
	let obj3 = {
		...obj2
	};
	obj2.x = 100;
	obj2.y[1] = 30;
	obj3.x = 200;
	obj3.y[2] = 40;
	obj = obj3.y = {
		x: 0,
		y: [1, 2]
	};
	console.log(obj, obj2, obj3);

</script>
<script src="">
	let a = 0,
		b = 0;
	function A(a) {
		A = function (b) {
			alert(a + b++);
		};
		alert(a++);
	}
	A(1);
	A(2);
</script>
<script src="">
	// 防抖
	function delty(fn, time = 1000) {

		return new Promise()

		let timer = null

		if (timer) clearTimeout(timer)

		timer = setTimeout(fn, time)
	}
</script>
<script src="">
	const p = new Promise((resolve, reject) => {
		// 这里一般存放即将要执行的异步任务，任务成功执行resolve，失败执行reject
		setTimeout(() => {
			if (Math.random() < 0.5) {
				reject("haha");
				return;
			}
			resolve("哈哈")
		}, 1000);
	})

	p.then(result => {
		console.log(result);  // 状态为fulfilled 成功后执行
	}).catch(err => {
		console.log(err);  // 状态为reject 失败后执行
	})
</script>
<script src="">
	let p1 = new Promise((resolve, reject) => {
		setTimeout(() => {
			resolve(100)
		}, 1000)
	});
	let p2 = new Promise((resolve, reject) => {
		setTimeout(() => {
			resolve(200)
		}, 500)
	});
	let p3 = new Promise((resolve, reject) => {
		setTimeout(() => {
			resolve(300)
		}, 300)
	});

	Promise.all([p1, p2, p3]).then(val => {  // 所有的内容都是成功，才会执行成功，发现一个失败直接就catch
		console.log(val);
	}).catch(err => {
		console.log(err);
	})


	Promise.any([p1, p2, p3]).then(val => {		// 发现一个成功，直接走成功，其余都不执行了，都是失败走catch
		console.log(val);
	}).catch(err => {
		console.log(err);
	})
</script>
<script src="">
	function fn1() {
		return new Promise((resolve, reject) => {
			$.get("./data.json", function (data) {
				resolve(data)
			})
		})
	}

	function fn2() {
		return new Promise((resolve, reject) => {
			$.get("./data.json", function (data) {
				reject(data)
			})
		})
	}

	async function getData() { 	//同步写法解决异步
		try {  	// 使用try和catch捕获异常
			let res1 = await fn1()
			let res2 = await fn2()
			console.log(res1, res2);
		} catch (err) {
			console.log("有失败的结果，执行中断了")
		}
	}

	getData()	 //调用
</script>


</html>